home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / CIncludes / fp.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-11  |  25.6 KB  |  595 lines  |  [TEXT/MPS ]
  1. /*******************************************************************************
  2. *                                                                              *
  3. *      File fp.h   -   PowerPC and 68K Macintosh                               *
  4. *                                                                              *
  5. *      A collection of numerical functions designed to facilitate a wide       *
  6. *      range of numerical programming. It is modeled after the Floating-Point  *
  7. *      C Extensions (FPCE) proposed technical draft of the Numerical C         *
  8. *      Extensions Group's requirements (NCEG / X3J11.1).                       *
  9. *      The <fp.h> declares many functions in support of numerical programming. *
  10. *      It provides a superset of <math.h> and <sane.h> functions.  Some        *
  11. *      functionality previously found in <sane.h> and not in the FPCE <fp.h>   *
  12. *      can be found in this <fp.h> under the heading "__NOEXTENSIONS__".       *
  13. *                                                                              *
  14. *      All of these functions are IEEE 754 aware and treat exceptions, NaNs,   *
  15. *      positive and negative zero and infinity consistent with the floating-   *
  16. *      point standard.                                                         *
  17. *                                                                              *
  18. *      Copyright © 1992 Apple Computer, Inc.  All rights reserved.             *
  19. *                                                                              *
  20. *      Written by Ali Sazegari, started on July 1992,                          *
  21. *      based on the file Numerics.h by Jim Thomas.                             *
  22. *                                                                              *
  23. *      October    27  1992: made changes for PowerPC, transfered some power    *
  24. *                           functions to <faux.h>.                             *
  25. *      October    30  1992: added long double data type for PowerPC and        *
  26. *                           merged it with the Macintosh <fp.h>.               *
  27. *      December   10  1992: changed logb, scalb, frexp and ldexp to            *
  28. *                           LOGB, SCALB, FREXP and LDEXP to avoid collision    *
  29. *                           with the ibm libc.                                 *
  30. *      December   16  1992: changed the flag "powerpc" to "powerc"             *
  31. *      February   17  1993: removed the typedefs and defrerred them to         *
  32. *                           <Types.h>.                                         *
  33. *      May        18  1993: added binary to decimal conversions for the        *
  34. *                           PowerPC.                                           *
  35. *      June       14  1993: added the long double decimal conversions, changed *
  36. *                           the decimal conversion prototypes to double_t.     *
  37. *      July       11  1993: changed the names of the long double bin2dec.      *
  38. *      August     23  1993: included C++ extern "C" wrappers to make them C++  *
  39. *                           friendly.                                          *
  40. *      November   29  1993: corrected a spelling mistake in the comments.      *
  41. *      February   22  1994: modf changed to double_t for 68K compatability PAF *
  42. *      February   22  1994: Comment changes PAF                                *
  43. *      April      26  1994: #define SIGDIGLEN 20 for 68K PAF                   *
  44. *      April      28  1994: collected all powerpc specific calls, changed      *
  45. *                           DECIMAL_DIG to 17.                                 *             
  46. *      May         2  1994: Added dec2d prototype and function to fp68K.c      *
  47. *      May         4  1994: Added #ifndef powerc prototype for trunc           *
  48. *      June       23  1994: Changed __inf() prototype to double_t.             *
  49. *                                                                              *
  50. *******************************************************************************/
  51.  
  52. #ifndef __FP__
  53. #define __FP__
  54.  
  55. /*      efficient types are included in Types.h.                              */
  56.  
  57. #ifndef __TYPES__
  58. #include <Types.h>
  59. #endif
  60.  
  61. /*******************************************************************************
  62. *                              Define some constants.                          *
  63. *******************************************************************************/
  64.  
  65. #ifdef      powerc
  66. #define      LONG_DOUBLE_SIZE         16
  67. #elif       mc68881
  68. #define      LONG_DOUBLE_SIZE         12
  69. #else
  70. #define      LONG_DOUBLE_SIZE         10
  71. #endif      /* powerc */
  72.  
  73. #define      DOUBLE_SIZE               8      
  74.  
  75. #define      HUGE_VAL                  __inf()
  76. #define      INFINITY                  __inf()
  77. #define      NAN                        nan("255")
  78.  
  79. /*    the macro DECIMAL_DIG is obtained by satisfying the constraint that the
  80.       conversion from double to decimal and back is the identity function.   */
  81.  
  82. #ifdef      powerc
  83. #define      DECIMAL_DIG              17 /* does not exist for double-double */
  84. #else
  85. #define      DECIMAL_DIG              21
  86. #endif      /* powerc */
  87.  
  88. #ifdef __cplusplus
  89. extern "C" {
  90. #endif
  91. /*******************************************************************************
  92. *                            Trigonometric functions                           *
  93. *******************************************************************************/
  94.  
  95. double_t cos ( double_t x );
  96. double_t sin ( double_t x );
  97. double_t tan ( double_t x );
  98.  
  99. double_t acos ( double_t x );            /*  argument x is in [0,pi]          */
  100. double_t asin ( double_t x );            /*  argument x is in [-pi/2,pi/2]    */
  101. double_t atan ( double_t x );            /*  argument x is in [-pi/2,pi/2]    */
  102.  
  103. /*    atan2 computes the arc tangent of y/x in [-pi,pi] using the sign of
  104.       both arguments to determine the quadrant of the computed value.         */
  105.  
  106. double_t atan2 ( double_t y, double_t x );
  107.  
  108. /*******************************************************************************
  109. *                              Hyperbolic functions                            *
  110. *******************************************************************************/
  111.  
  112. double_t cosh ( double_t x );
  113. double_t sinh ( double_t x );
  114. double_t tanh ( double_t x );
  115.  
  116. double_t acosh ( double_t x );
  117. double_t asinh ( double_t x );
  118. double_t atanh ( double_t x );
  119.  
  120. /*******************************************************************************
  121. *                              Exponential functions                           *
  122. *******************************************************************************/
  123.  
  124. double_t exp ( double_t x );
  125.  
  126. /*    expm1 computes the base e exponential of the argument minus 1,
  127.       i. e., exp(x) - 1.  For small enough arguments, expm1 is expected
  128.       to be more accurate than the straight forward computation of exp(x) - 1.*/
  129.  
  130. double_t expm1  ( double_t x );
  131. double_t exp2  ( double_t x );
  132.  
  133. double_t frexp ( double_t x, int *exponent );
  134. double_t ldexp ( double_t x, int n );
  135.  
  136. double_t log ( double_t x );
  137. double_t log2 ( double_t x );
  138.  
  139. /*    log1p computes the base e logorithm of 1 plus the argument,
  140.       i. e., log (1+x).  For small enough arguments, log1p is expected
  141.       to be more accurate than the straightforward computation of log (1+x).  */
  142.  
  143. double_t log1p ( double_t x );
  144. double_t log10 ( double_t x ); 
  145.  
  146. /*    logb extracts the exponent of its argument, as a signed integral
  147.       value. A subnormal argument is treated as though it were first
  148.       normalized. Thus
  149.  
  150.       1 <= x * 2^( - Logb ( x ) ) < 2                                         */
  151.  
  152. double_t logb ( double_t x );
  153.  
  154. long double modfl ( long double x, long double *iptrl );
  155. double_t    modf  ( double_t x, double_t *iptr );  // <- note NCEG difference
  156. float       modff ( float x, float *iptrf );
  157.  
  158. /*    scalb computes x * 2^n efficently.  This is not normally done by
  159.       computing 2^n explicitly.                                               */
  160.  
  161. double_t scalb ( double_t x, long int n ); 
  162.  
  163. /*******************************************************************************
  164. *                     Power and absolute value functions                       *
  165. *******************************************************************************/
  166.  
  167. double_t fabs ( double_t x );
  168.  
  169. /*    hypot computes the square root of the sum of the squares of its
  170.       arguments, without undue overflow or underflow.                         */
  171.  
  172. double_t hypot ( double_t x, double_t y );
  173. double_t pow   ( double_t x, double_t y );
  174. double_t sqrt  ( double_t x );
  175.  
  176. /*******************************************************************************
  177. *                        Gamma and Error functions                             *
  178. *******************************************************************************/
  179.  
  180. double_t erf  ( double_t x );            /*   the error function              */
  181. double_t erfc ( double_t x );            /*   complementary error function    */
  182.  
  183. double_t gamma ( double_t x );
  184.  
  185. /*    lgamma computes the base-e logarithm of the absolute value of
  186.       gamma of its argument x, for x > 0.                                     */
  187.  
  188. double_t lgamma ( double_t x );
  189.  
  190. /*******************************************************************************
  191. *                        Nearest integer functions                             *
  192. *******************************************************************************/
  193.  
  194. double_t ceil  ( double_t x );
  195. double_t floor ( double_t x ); 
  196.  
  197. /*    the rint function rounds its argument to an integral value in floating
  198.       point format, honoring the current rounding direction.                  */
  199.  
  200. double_t rint ( double_t x );
  201.  
  202. /*    nearbyint differs from rint only in that it does not raise the
  203.       inexact exception. It is the nearbyint function recommended by the
  204.       IEEE floating-point standard 854.                                       */
  205.  
  206. double_t nearbyint ( double_t x );
  207.  
  208. /*    the function rinttol rounds its argument to the nearest long int using
  209.       the current rounding direction.
  210.       >>Note that if the rounded value is outside the range of long int, then
  211.       the result is undefined.                                                */
  212.  
  213. long int rinttol ( double_t x );
  214.  
  215. /*    the round function rounds the argument to the nearest integral value
  216.       in double format similar to the Fortran "anint" function.  That is:
  217.       add half to the magnitude and chop.                                     */
  218.  
  219. double_t round ( double_t x );
  220.  
  221. /*    roundtol is similar to the Fortran function nint or to the Pascal round
  222.       >>Note that if the rounded value is outside the range of long int, then
  223.       the result is undefined.                                                */
  224.  
  225. long int roundtol ( double_t round );
  226.  
  227. /*    trunc computes the integral value, in floating format, nearest to
  228.       but no larger in magnitude than its argument.                           */
  229.  
  230. #ifndef powerc
  231. // necessary because trunc is implicitly declared this way when -elems881 is set
  232. int      trunc ( double_t x );      /*  Round to integer in direction of zero */
  233. #else
  234. double_t trunc ( double_t x );
  235. #endif
  236.  
  237. /*******************************************************************************
  238. *                            Remainder functions                               *
  239. *******************************************************************************/
  240.  
  241. double_t fmod ( double_t x, double_t y );
  242.  
  243. /*    the following two functions compute the remainder.  remainder is required
  244.       by the IEEE 754 floating point standard. The second form correponds to the
  245.       SANE remainder; it stores into 'quotient' the 7 low-order bits of the
  246.       integer quotient x/y, such that -127 <= quotient <= 127.                */
  247.  
  248. double_t remainder ( double_t x, double_t y );
  249. double_t remquo    ( double_t x, double_t y, int *quo );
  250.  
  251. /*******************************************************************************
  252. *                             Auxiliary functions                              *
  253. *******************************************************************************/
  254.  
  255. /*    copysign produces a value with the magnitude of its first argument
  256.       and sign of its second argument. NOTE: the order of the arguments
  257.       matches the recommendation of the IEEE 754 floating point standard,
  258.       which is opposite from the SANE copysign function.                      */
  259.  
  260. double_t copysign ( double_t x, double_t y );
  261.  
  262. /*    the call 'nan ( "n-char-sequence" )' returns a quiet NaN with content
  263.       indicated through tagp in the selected data type format.                */
  264.  
  265. long double nanl ( const char *tagp );
  266. double      nan  ( const char *tagp );
  267. float       nanf ( const char *tagp );
  268.  
  269. /*    these compute the next representable value, in the type indicated,
  270.       after 'x' in the direction of 'y'.  if x == y then y is returned.       */
  271.  
  272. long double nextafterl ( long double x, long double y );
  273. double      nextafterd ( double x, double y );
  274. float       nextafterf ( float x, float y );
  275.  
  276. /*******************************************************************************
  277. *                              Inquiry macros                                  *
  278. *******************************************************************************/
  279.  
  280. enum NumberKind
  281.             {
  282.             FP_SNAN = 0,        /*      signaling NaN                         */
  283.             FP_QNAN,            /*      quiet NaN                             */
  284.             FP_INFINITE,        /*      + or - infinity                       */
  285.             FP_ZERO,            /*      + or - zero                           */
  286.             FP_NORMAL,          /*      all normal numbers                    */
  287.             FP_SUBNORMAL        /*      denormal numbers                      */
  288.             };
  289.  
  290. #define      fpclassify(x)    ( ( sizeof ( x ) == LONG_DOUBLE_SIZE ) ?         \
  291.                               __fpclassify  ( x ) :                            \
  292.                                 ( sizeof ( x ) == DOUBLE_SIZE ) ?              \
  293.                               __fpclassifyd ( x ) :                            \
  294.                               __fpclassifyf ( x ) )
  295.  
  296. /*    isnormal is non-zero if and only if the argument x is normalized.       */
  297.  
  298. #define      isnormal(x)      ( ( sizeof ( x ) == LONG_DOUBLE_SIZE ) ?         \
  299.                               __isnormal ( x ) :                               \
  300.                                 ( sizeof ( x ) == DOUBLE_SIZE ) ?              \
  301.                               __isnormald ( x ) :                              \
  302.                               __isnormalf ( x ) )
  303.  
  304. /*    isfinite is non-zero if and only if the argument x is finite.           */
  305.  
  306. #define      isfinite(x)      ( ( sizeof ( x ) == LONG_DOUBLE_SIZE ) ?         \
  307.                               __isfinite ( x ) :                               \
  308.                                 ( sizeof ( x ) == DOUBLE_SIZE ) ?              \
  309.                               __isfinited ( x ) :                              \
  310.                               __isfinitef ( x ) )
  311.  
  312. /*    isnan is non-zero if and only if the argument x is a NaN.               */
  313.  
  314. #define      isnan(x)         ( ( sizeof ( x ) == LONG_DOUBLE_SIZE ) ?         \
  315.                               __isnan ( x ) :                                  \
  316.                               ( sizeof ( x ) == DOUBLE_SIZE ) ?                \
  317.                               __isnand ( x ) :                                 \
  318.                               __isnanf ( x ) )
  319.  
  320. /*    signbit is non-zero if and only if the sign of the argument x is
  321.       negative. this includes, NaNs, infinities and zeros.                    */
  322.  
  323. #define      signbit(x)       ( ( sizeof ( x ) == LONG_DOUBLE_SIZE ) ?         \
  324.                               __signbit ( x ) :                                \
  325.                               ( sizeof ( x ) == DOUBLE_SIZE ) ?                \
  326.                               __signbitd ( x ) :                               \
  327.                               __signbitf ( x ) )
  328.  
  329. /*******************************************************************************
  330. *                      Max, Min and Positive Difference                        *
  331. *******************************************************************************/
  332.  
  333. /*    These extension functions correspond to the standard functions, dim
  334.       max and min.
  335.  
  336.       The fdim function determines the 'positive difference' between its
  337.       arguments: { x - y, if x > y }, { +0, if x <= y }.  If one argument is
  338.       NaN, then fdim returns that NaN.  if both arguments are NaNs, then fdim
  339.       returns the first argument.                                             */
  340.  
  341. double_t fdim ( double_t x, double_t y );
  342.  
  343. /*    max and min return the maximum and minimum of their two arguments,
  344.       respectively.  They correspond to the max and min functions in FORTRAN.
  345.       NaN arguments are treated as missing data.  If one argument is NaN and
  346.       the other is a number, then the number is returned.  If both are NaNs
  347.       then the first argument is returned.                                    */
  348.  
  349. double_t fmax ( double_t x, double_t y );
  350. double_t fmin ( double_t x, double_t y );
  351.  
  352. /*******************************************************************************
  353. *                                Constants                                     *
  354. *******************************************************************************/
  355.  
  356. extern const double_t pi;
  357.  
  358. /*******************************************************************************
  359. *                              Internal prototypes                             *
  360. *******************************************************************************/
  361.  
  362. long int __fpclassify  ( long double x ); 
  363. long int __fpclassifyd ( double x );
  364. long int __fpclassifyf ( float x );
  365.  
  366. long int __isnormal  ( long double x );
  367. long int __isnormald ( double x );
  368. long int __isnormalf ( float x );
  369.  
  370. long int __isfinite  ( long double x );
  371. long int __isfinited ( double x );
  372. long int __isfinitef ( float x );
  373.  
  374. long int __isnan  ( long double x );
  375. long int __isnand ( double x );
  376. long int __isnanf ( float x );
  377.  
  378. long int __signbit  ( long double x );
  379. long int __signbitd ( double x );
  380. long int __signbitf ( float x );
  381.  
  382. double_t __inf ( void );
  383.  
  384. /*******************************************************************************
  385. *                              Non NCEG extensions                             *
  386. *******************************************************************************/
  387.  
  388. #ifndef __NOEXTENSIONS__
  389.  
  390. /*******************************************************************************
  391. *                              Financial functions                             *
  392. *******************************************************************************/
  393.  
  394. /*    compound computes the compound interest factor "(1 + rate) ^ periods"
  395.       more accurately than the straightforward computation with the Power
  396.       function.  This is SANE's compound function.                            */
  397.  
  398. double_t compound ( double_t rate, double_t periods );
  399.  
  400. /*    The function annuity computes the present value factor for an annuity 
  401.       "( 1 - ( 1 + rate ) ^ ( - periods ) ) / rate" more accurately than the
  402.       straightforward computation with the Power function. This is SANE's 
  403.       annuity function.                                                       */
  404.  
  405. double_t annuity ( double_t rate, double_t periods );
  406.  
  407. /*******************************************************************************
  408. *                              Random function                                 *
  409. *******************************************************************************/
  410.  
  411. double_t randomx ( double_t *x );
  412.  
  413. /*******************************************************************************
  414. *                              Relational operator                             *
  415. *******************************************************************************/
  416.  
  417. typedef short relop;                         /*      relational operator      */
  418.  
  419. enum 
  420.       {
  421.       GREATERTHAN = ( ( relop ) ( 0 ) ),
  422.       LESSTHAN,
  423.       EQUALTO,
  424.       UNORDERED
  425.       };
  426.  
  427. relop relation ( double_t x, double_t y );
  428.  
  429. /*******************************************************************************
  430. *                         Binary to decimal conversions                        *
  431. *******************************************************************************/
  432.  
  433. #ifdef      powerc
  434. #define      SIGDIGLEN      36               /*    significant decimal digits */
  435. #else
  436. #define      SIGDIGLEN      20               /*    significant decimal digits */
  437. #endif
  438.  
  439. #define      DECSTROUTLEN   80               /* max length for dec2str output */
  440. #define      FLOATDECIMAL   ((char)(0))
  441. #define      FIXEDDECIMAL   ((char)(1))
  442.  
  443. /*    The decimal record type provides an intermediate unpacked form for
  444.       programmers who wish to do their own parsing of numeric input or
  445.       formatting of numeric output.                                           */
  446.     
  447. struct decimal 
  448.      {
  449.       char sgn;                              /*         sign 0 for +, 1 for - */
  450.       char unused;
  451.       short exp;                             /*              decimal exponent */
  452.       struct
  453.             {
  454.             unsigned char length;
  455.             unsigned char text[SIGDIGLEN];   /*            significant digits */
  456.             unsigned char unused;
  457.             }sig;
  458.       };
  459.  
  460. typedef struct decimal decimal;
  461.  
  462. /*    Each conversion to a decimal string is controlled by a decform
  463.       structure.  The style is either FLOATDECIMAL or FIXEDDECIMAL defined
  464.       above.  The value of digits is the number of significant digits for
  465.       FLOATDECIMAL.  The value of digits for FIXEDDECIMAL is the number of
  466.       digits to the right of the decimal point.                               */
  467.  
  468. struct decform 
  469.       {
  470.       char style;                            /*  FLOATDECIMAL or FIXEDDECIMAL */
  471.       char unused;
  472.       short digits;
  473.       };
  474.  
  475. typedef struct decform decform;
  476.  
  477. /*    Each conversion to a decimal record d via the function call num2dec is 
  478.       controlled by a decform record f (defined earlier), to a double_t x.    */
  479.  
  480. void num2dec ( const decform *f, double_t x, decimal *d );
  481.  
  482. /*    dec2num converts a decimal record d to a double_t value.                */
  483.  
  484. double_t dec2num ( const decimal *d );
  485.  
  486. /*    The MathLib formatter dec2str is controlled by a decform f.  Input d is
  487.       a decimal record.                                                       */
  488.  
  489. void dec2str ( const decform *f, const decimal *d, char *s );
  490.  
  491. /*    The function str2dec is the MathLib scanner.                            */
  492.  
  493. void str2dec ( const char *s, short *ix, decimal *d, short *vp ); 
  494.  
  495. /*    dec2d is similar to dec2num except a double is returned on 68k platforms*/
  496.  
  497. #ifndef powerc
  498. double dec2d ( const decimal *d );
  499. #endif
  500.  
  501. /*    dec2f is similar to dec2num except a float is returned.                 */
  502.  
  503. float dec2f ( const decimal *d );
  504.  
  505. /*    dec2s is similar to dec2num except a short is returned.                 */
  506.  
  507. short int dec2s ( const decimal *d );
  508.  
  509. /*    dec2l is similar to dec2num except a long is returned.                  */
  510.  
  511. long int dec2l  ( const decimal *d );
  512.  
  513. #endif      /* __NOEXTENSIONS__ */
  514.  
  515. /*******************************************************************************
  516. *                         PowerPC-only Function Prototypes                     *
  517. *******************************************************************************/
  518.  
  519. #ifdef      powerc
  520.  
  521. long double cosl ( long double x );
  522. long double sinl ( long double x );
  523. long double tanl ( long double x );
  524.  
  525. long double acosl ( long double x );      /*  argument x is in [0,pi]         */
  526. long double asinl ( long double x );      /*  argument x is in [-pi/2,pi/2]   */
  527. long double atanl ( long double x );      /*  argument x is in [-pi/2,pi/2]   */
  528. long double atan2l ( long double y, long double x );
  529.  
  530. long double coshl ( long double x );
  531. long double sinhl ( long double x );
  532. long double tanhl ( long double x );
  533.  
  534. long double acoshl ( long double x );
  535. long double asinhl ( long double x );
  536. long double atanhl ( long double x );
  537.  
  538. long double expl ( long double x );
  539. long double expm1l ( long double x );
  540. long double exp2l  ( long double x );
  541.  
  542. long double frexpl ( long double x, int *exponent );
  543. long double ldexpl ( long double x, int n );
  544.  
  545. long double logl ( long double x );
  546. long double log1pl ( long double x );
  547. long double log10l ( long double x ); 
  548. long double log2l ( long double x );
  549.  
  550. long double logbl ( long double x );
  551. long double scalbl ( long double x, long int n ); 
  552.  
  553. long double fabsl ( long double x );
  554. long double hypotl ( long double x, long double y );
  555. long double powl   ( long double x, long double y );
  556. long double sqrtl  ( long double x );
  557.  
  558. long double erfl  ( long double x );     /*   the error function              */
  559. long double erfcl ( long double x );     /*   complementary error function    */
  560. long double gammal ( long double x );
  561. long double lgammal ( long double x );
  562.  
  563. long double ceill  ( long double x );
  564. long double floorl ( long double x );
  565. long double rintl ( long double x );
  566. long double nearbyintl ( long double x );
  567. long int rinttoll ( long double x );
  568. long double roundl ( long double x );
  569. long int roundtoll ( long double round );
  570. long double truncl ( long double x );
  571. long double remainderl ( long double x, long double y );
  572. long double remquol    ( long double x, long double y, int *quo );
  573. long double copysignl ( long double x, long double y );
  574. long double fdiml ( long double x, long double y );
  575. long double fmaxl ( long double x, long double y );
  576. long double fminl ( long double x, long double y );
  577.  
  578. #ifndef __NOEXTENSIONS__
  579.  
  580. relop relationl ( long double x, long double y );
  581. void x80told ( const extended80 *x80, long double *x );
  582. void ldtox80 ( const long double *x, extended80 *x80 );
  583. void num2decl ( const decform *f, long double x, decimal *d );
  584. long double dec2numl ( const decimal *d );
  585.  
  586. #endif      /* __NOEXTENSIONS__ */
  587.  
  588. #endif      /* powerc           */
  589.  
  590. #ifdef __cplusplus
  591. }
  592. #endif
  593.  
  594. #endif      /* __FP__          */
  595.